Modeling system for retrieving and displaying data from multiple sources

ABSTRACT

A model development system provides tools for developers to define reusable, object oriented components and views for collecting and displaying data from multiple sources, and for incorporating such reusable components and views into an informational model. Using the system, a developer can create a reusable component, create multiple instances of that component, and connect each such instance to one or more corresponding back-end data sources. The developer can also define one or more associated views that specify how data collected by the component from the back-end data sources is to be displayed. Many different components and views may be defined and deployed to build an informational model of a business entity, such as a business that operates processing or manufacturing plants in various locations.

RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No.10/726,430, filed Dec. 3, 2003, which is a continuation of Ser. No.09/704,471, filed Nov. 1, 2000, claims the priority date of U.S.provisional patent application No. 60/162,975, filed Nov. 1, 1999, whichis hereby incorporated by reference.

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates to collecting, modeling, and providingaccess to information.

2. Description of the Related Art

A number of attempts have been made to retrieve data from a businessorganization's various data sources (called back-end data sources) andto present that data to users. An organization's various back-end datasources may contain different types and formats of data, includingrelational data, point data, time-series data, and object data.Relational data comprise data from multiple tables of multiple fields.The tables may be related to each other through indexes. Point data issingle-type data typically associated with manufacturing systems. Forexample, a data system may continuously collect a motor's operatingspeed and operating temperature as point data. Unlike relational data,point data typically are not comprised of multiple tables. Time-seriesdata are data that store the change in data value over time. Object dataare data represented by objects. The concepts of object, object-orienteddesign, object-oriented programming and object- oriented databases areknown to those skilled in the art.

Data warehouse products and more custom database approaches typicallycollect data from back-end data sources and deposit the data into a newdata warehouse (or data mart) for data analysis and presentation. Somedata mining processes operate on data warehouses to provide detailedanalysis such as marketing and sales trends, and to test hypotheses suchas customer buying patterns. However, those analyses are usually onlyavailable to a few analysts and executives in an organization. Inaddition, a data warehouse usually stores historical data for long termanalysis, but is not suitable for real time or near real timeapplications.

Application packages such as Intellution Dynamics Package byIntellution, Inc. of Foxborough, Mass. and InTouch by WonderwareCorporation of Irvine, Calif. provide for visualization of plantoperational data in some manufacturing systems. These packages have verylimited abilities to retrieve and present relational data typicallyassociated with other manufacturing systems and non-manufacturingsystems such as enterprise resource planning (ERP) systems. Typically,the major limitations include an inability to monitor relational data asit changes over time, navigate the relational data for more detailedmonitoring or status, and to find supporting details. Because they donot provide access to both point data and relational data, enterprisesoften have to use multiple systems to provide data visualization,navigation and analysis of various types and formats of data. Usingmultiple systems often results in high financial and computing expensesand programming and administrative complexity.

Some systems convert back-end data into relational data stored in arelational database for selection, analysis and visual presentation.Such a relational database typically needs to be managed by a databaseadministrator in order to handle the complexity of a relational databasecomprising multiple tables and indexes. This is especially true whendata has to be converted and acquired from different back-end systems.In addition, those systems cannot utilize the advantages of object data.

Some systems convert point data and relational data from back-end datasources into point data to present to users. Since the back-end data areconverted into point data, those systems cannot utilize the advantagesof object data and also lose any benefits associated with relationaldata.

Other systems convert back-end data into object data, but fail toprovide access to the object data using a class-based representationmodel. What is needed is a system and method providing access toback-end data in object form, in real time, and using a class-basedcomponent and view model.

SUMMARY

One aspect of the invention involves the use of a class-based componentand view model to collect and display data from multiple sources. Theclass-based component and view model is preferably embodied within asystem that uses reusable components and views to monitor the operationof a business entity, such as but not limited to a business entity thathas manufacturing facilities or plants in various locations. The datathat is collected and displayed by the system may, for example, includerelational data, point data and/or time-series data. The system alsopreferably includes development tools for creating and deploying thereusable components and views to generate an information model formonitoring the business entity.

To generate a model in a preferred embodiment, reusable components areinitially defined for each type of business element or data source to bemonitored. For example, a “plant” component may be generated thatrepresents the general structure of a manufacturing or processing plant,and a “pump” component may be generated to represent a type of pump. Agiven component may include one or more other components as members. Forexample, if each plant within the business entity includes multiplepumps, the associated plant component may include multiple pumpcomponents. The task of generating the reusable components is performedin the preferred embodiment using a component builder tool.

In addition to defining reusable components, one or more reusable viewsmay be defined for a given component to specify how data collected bythat component is to be displayed. Each such view is generally agraphical representation of a corresponding component, and may includegraphs, charts, animations, and/or other types of graphical elements torepresent the associated data collected by that component. If a firstcomponent is a member of a second component, a first view associatedwith the first component may optionally be inserted into a second viewassociated with the second component, such that the first view isautomatically displayed as a subset of the second view. The task ofgenerating the reusable views is performed in the preferred embodimentusing a view builder tool.

The system preferably allows multiple views to be defined for the samecomponent, and thus allows users or developers to build different viewsof varying levels of detail corresponding to the same component. This isadvantageous because different people within a business organization maydemand different views that connect to the same data. For example, aplant foreman may want views that show the operating temperature, speedand production numbers of machines. The plant supervisor may want viewsthat show the production numbers of machines. The company executive maywant views that show the production totals of each plant. Some prefer tohave data displayed in tables while others prefer charts.

Once one or more reusable components and associated views have beengenerated, a solution builder tool may be used to generate aninformational model or “solution” for a business entity. This taskinvolves creating instances of specific components, and connecting theseinstances to respective back end data sources. For example, if a givenbusiness entity has physical plants in Chicago, Milwaukee and Cleveland,three separate instances of the “plant” component may be created, onefor each physical plant. Each such component instance would also beconnected to the corresponding back end data source or sources (pointdata sources, databases, etc.) associated with its respective physicalplant. As part of this process, different data collection frequenciesand other data connection parameters may be specified for differentinstances of the same component. The task of creating a solution from aset of preexisting components can advantageously be performed by aperson having little or no knowledge of the structure of the associatedcomponents. If changes are made to a particular component or its view(s)over time, the changes may be propagated automatically to all instancesof the associated component.

The solution or model may be navigated in the preferred embodiment usinga navigation tree in which each instance of each component isrepresented by a respective node or icon within an expandable tree.Using the navigation tree, a user can select a node (component instance)and view the associated data collected by that instance. If multipleviews have been defined for an associated component (e.g., basic view,detailed view, etc.), the user can also select between these alternativeviews. In one embodiment, users can access the navigation tree using anordinary web browser.

Neither this summary nor the following detailed description purports todefine the invention. The invention is defined by the claims.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates components and environments that use one embodimentof the present invention.

FIG. 2 illustrates a representation of modules of an applicationenvironment and a development environment in accordance with oneembodiment of the present invention.

FIG. 3 illustrates the tree-style solution display and navigationstructure of the preferred embodiment.

FIG. 4 illustrates an embodiment of the data communication between theapplication environment and the back-end data environment.

FIG. 5 illustrates an embodiment of the data communication between theapplication environment and the browsing environment.

FIG. 6 is a flowchart illustrating a process of creating a component.

FIG. 7 is a flowchart illustrating a process of creating a globalcollection.

FIG. 8 is a flowchart illustrating a process of creating a solution.

FIG. 9 is a flowchart illustrating a process of creating a view.

FIG. 10 is an example screen display of the component builder of FIG. 2illustrating a user interface for adding an existing component member toa component.

FIG. 11 illustrates a screen display of the solution builder of FIG. 2,showing an example solution tree on the left hand side.

FIG. 12 illustrates a user interface through which a user of thesolution builder can select from a list of views that are available fora selected component/component instance in the solution tree.

FIG. 13 illustrates a connection tab screen of the solution builder.

FIG. 14 is an example screen display of the solution builderillustrating the process of connecting a collection component to aglobal collection called “Customers.”

FIG. 15 is an example screen display of the view builder of FIG. 2illustrating the process of inserting one view into another view.

FIG. 16 illustrates a browser-based view of a solution, with thesolution tree shown in the left panel and a populated view of theselected component instance in the right panel.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

FIG. 1 illustrates components and environments according to oneembodiment of the present invention. A back-end data environment 100comprises various data sources, such as plant floor production systems102, enterprise resource planning data systems 104, and other datasystems 106. Such data sources contain data of various formats, such asrelational data, point data, time-series data, object data, or acombination thereof. The various data sources from the back-end dataenvironment 100 are connected to an application environment 200. As usedherein, the term connected means directly or indirectly capable ofcommunicating over a direct wired, network or wireless connection.

The application environment 200 comprises an enterprise server 202, aweb server 204, and one or more solution servers 206. The applicationenvironment 200 is connected to a development environment 201. Thedevelopment environment 201 comprises one or more development clients210. In the preferred embodiment, the enterprise server, solutionservers and development clients comprise application programs in Javaand/or C++and running under Windows NT.

The application environment 200 is connected to a browsing environment300. The browsing environment 300 comprises one or more browsingterminals 302. Each browsing terminal 302 comprises a communicationprogram such as a web browser. In the preferred embodiment the browsingterminals 302 are connected to the application environment 200 throughthe Internet using web browsers such as Netscape Communicator orInternet Explorer launched from the browsing terminals 302. In anotherembodiment, the browsing terminals 302 are connected to the applicationenvironment 200 through an Intranet.

The system provides options for a developer or user to specify thefrequency at which data is to be fetched from the back-end environment100 into the application environment 200. If data were fetched toofrequently, it would be a waste on system resources and may adverselyaffect system performance. On the other hand, if the data were notfetched frequently enough, a user could end up viewing data that isunacceptably out-dated. By fine-tuning the fetching frequency, adeveloper or user can ensure that users view data that is sufficientlytimely. The system and method for specifying the data fetch frequenciesare known to those skilled in the art.

FIG. 2 illustrates a representation of modules of the applicationenvironment 200, and the development environment 201. While thepreferred embodiment may comprise multiple solution servers and multipledevelopment clients, only one solution server 206 and only onedevelopment client 210 are shown on FIG. 2 for ease of illustration.

The enterprise server 202 comprises a component table 222 that storescomponent definitions. A component is a reusable software resource thatcontains and represents the information associated with a data source,such as a business entity. Thus, for example, a component may representa customer, a shipping route, or a credit check process. A component canrepresent a collection, for example, yesterday's customer orders from aback-end relational database. By using components to represent businesselements, the system facilitates user understanding in terms of thebusiness process. A component is made up of one or more members. Eachmember can be a number, a date, a text string, a Boolean logical value,or another component. For example, a “customer” component may becomprised of members such as name, identification number and address. Arun-time usage of a component is called a component instance. When acomponent is reused, a unique instance of that component is created,with a unique name. Different instances of the same component can followdifferent instructions on where, when, how and how often to retrieveback-end data.

For each component represented in the component table 222, the componenttable 222 also stores definitions of views associated with thatcomponent. By storing all component and view definitions on theenterprise server 202, the system ensures that all developers and usersacross the enterprise can utilize and inherit the same component andview definitions. The enterprise server 202 also comprises a solutiontable 226 that stores the names, descriptions and locations ofsolutions, and a connector table 228 that stores the name, descriptionand configuration code of all connectors. The connection processconfigurations are stored in the solution servers 206 in the connectionprocesses module. The connection processes that execute commands toacquire component instance data and global collection data from back-enddata sources are located on the solution servers 206. A solution is acomponent instance with a defined connection to a back-end data. Aconnector comprises program code for connecting a component instance ora global collection to a back-end data source. A global collectionrepresents multiple instances of the same class of data, such as “allorders,” “all customers,” or “all customers from the East Region.”

The web server 204 comprises an animation module 252 which displaysviews with animation effects and manages user interaction with theviews, a trend module 254 which displays trends of component instancedata change as data change over time, a navigation module 256 whichmanages the tree-structure navigation of views, and a support module 258which supports data communication between the application environment200 and the browsing environment 300. In one embodiment, the animationmodule 252, the trend module 254, the navigation module 256 and thesupport module 258 comprise one or more Java applets. The web server 204also comprises a router 260 as the data communication gateway betweenthe browsing terminals 302 and the application environment 200.

The solution server 206 comprises an object storage 232, a time-serieshistorian 234, a component instance table 236, a connection group table238 and a connection processes module 240. The object storage 232receives data from the back-end data environment 100 and stores suchdata. The object storage 232 stores some objects in memory and commitsother objects to disk to allow for storing large quantities of data.Those of ordinary skill will appreciate that objects may be storedentirely in memory or on disk or on other media, and the presentinvention is not limited by the type of media used to store objects.

Even if users want the same data, the data only needs to be retrievedfrom the back-end environment 100 once, and can then be transmitted fromthe object storage 232 to one or many users who request it. Since thedata are stored directly in memory or disk, and not in a relationaldatabase, the data administration task is typically simpler than arelational database.

The time-series historian 234 is a database preferably optimized forstoring time-centric data. The time series historian 234 storestime-stamped data values received from the back-end data environment100. The time-series historian 234 can be an independent third-partyproduct or can be custom-designed. It will be appreciated by those ofordinary skill that a flat file system or database may be used toimplement the time-series historian 234.

The component instance table 236 stores the connection configurationsfor each component instance within the solution held by that solutionserver 206. The connection configurations comprise a connection group toconnect to the back-end data, or a program command to select a subset ofa global collection, as described in connection with FIG. 7.

A connection group comprises a connection process and a connector. Aconnection process is the program command that starts the execution ofthe connector. The connection group table 238 stores connection groups.

The connection processes module 240 comprises a table storing connectionprocesses and their respective locations. The connection processesmodule 240 uses connection processes to retrieve data from the back-enddata environment 100, and sends the retrieved data to the object storage232. If a user or developer selects, for example, in the solutionbuilder 248, an option to store data in time-series historian, theconnection processes module 240 sends the retrieved data to thetime-series historian 234 for storing.

The development client 210 comprises a catalog application 242, acomponent builder 244, a view builder 246, a solution builder 248, and aconnector builder 250. Components and views are created or modifiedwithin the development client 210 and sent to the enterprise server 202to be stored in the component table 222. The catalog application 242 isan interface that includes and provides access to a list of components.Each component is represented by a component name and an icon. When adeveloper or user selects a component from the list for modification orstarts to create a new component, the developer/user is directed fromthe catalog application 242 to the component builder 244. The componentbuilder 244 allows a developer or user to create and edit components.

When a developer/user selects a component from the catalog application242, the developer/user may select the menu option “create new view” tocreate a new view for that component, or may select the menu option“edit view” to edit a view for that component. The developer/user willthen be directed from the catalog application 242 to the view builder246. The view builder 246 allows a developer or user to create and editviews to attach to existing components.

The solution builder 248 allows a developer or user to create or modifya solution, and to specify how to connect the solution to back-end datasources. In one embodiment, the present invention supports Microsoft'sDynamic Data Exchange (DDE) protocol and Microsoft's Open DatabaseConnectivity (ODBC) application programming interface for connecting toback-end data sources. An example screen display of one embodiment ofthe solution builder 248 is shown in FIG. 11, with a solution tree shownon the left hand side. Another example screen display is shown in FIG.12, which shows how a user of the solution builder 248 can select from alist of views that are available for a selected component instance toview data collected by that instance.

The connector builder 250 allows a developer or user to add, modify ordelete a connector. A connector is the program code that connects toback-end data. The created or modified connector definitions aretransmitted from the connector builder 250 to the enterprise server 202and stored in the connector table 228. Each connector has an associatedconnector type such as ODBC, DDE, Oracle or MS-SQL.

FIG. 3 illustrates a tree style navigation and display structurerepresenting solutions. As FIG. 3 illustrates, the top node solution“enterprise” 402 comprises several member solutions representing plantsin Chicago, Indianapolis, and Milwaukee. The Chicago plant 404, theIndianapolis plant 406, the Milwaukee plant 408 and the Cleveland plant410 are solutions each corresponding to a “plant” component, but withdifferent connections to back-end data. In one embodiment of the presentinvention, the component “plant” comprises the members “bottling line,”“can line,” “human resource,” and “maintenance,” each such member beinga component. Therefore, the Chicago plant 404 has a bottling line 412, acan line 414, a human resource department 416 and a maintenancedepartment 418. The other plants have the same members but may connectto different back-end data.

The tree style display and navigation structure is preferred because itis visually intuitive. A tree branch may comprise sub-branches, as acomponent may comprise member components. However, solutions may also bedisplayed using other presentation and navigation structures.Programming controls, such as the Visual Basic Tree View control, areknown to those of ordinary skill, and can be used to generate navigabledisplays representing hierarchical relationships between objects by avisual arrangement of labels and/or icons associated with representedobjects. See, for example, Microsoft Visual Basic —ProfessionalFeatures, Microsoft Corp., 1995.

At run time, a solution represents an instance of a correspondingcomponent. A developer or user can define and modify the run-timeattributes of a solution component instance, such as name, description,and connection characteristics. Such connection characteristics mayinclude what data sources to connect to, when to connect, the programcode or system command to connect to a data source and retrieve data,and how frequently to retrieve data. When one or more components thatmake up a solution have been changed, i.e., when members are added to,modified, or deleted from a component, or the name or icon of thecomponent has been changed, a developer or user may update the solutionthrough a menu option. This action updates the solution to include thelatest changes to the components.

A node “global collections” and a sub-node “customers” are displayed atthe bottom of the solution tree in FIG. 3. The global collection sectionwill be described in connection with FIG. 7.

FIG. 4 illustrates the back-end data environment 100 connected to theapplication environment 200, through solution server 206. While multiplesolution servers may be connected to the back-end data environment 100,only one solution server 206 is shown for ease of illustration. Theconnection processes module 240 retrieves data from the back-end dataenvironment 100 and sends the retrieved data to the object storage 232.If specified in the solution builder 248 to be stored in the time-serieshistorian 234, then the retrieved data is also stored in the time-serieshistorian 234.

The object storage 232 receives and stores relational data and pointdata. Point data is retrieved by the connection processes module 240from the back-end data environment 100 to the object storage 232, when aview corresponding to such point data is displayed on a browsingterminal 302. This run-time retrieval of point data retrieves only theset or subset of point data that is requested by the displaying view,and only when requested.

Relational data and other collection data are retrieved by theconnection processes module 240 from the back-end data environment 100,to the object storage 232, when a solution connects such relational datato the solution using a connection group. A solution can also connect toback-end data by selecting a subset of a global collection that connectsto back-end data. In one embodiment, a process connected to therelational data source in the back-end data environment 100automatically detects changes and sends changes to the back-end data aschange records to the object storage 232 and the recorded changes areapplied to the data in the object storage 232. This method of applyingchanges reduces the quantity of data needed to be retrieved from theback-end data environment 100. In another embodiment, the back-end dataenvironment 100 does not create change records, and data from theback-end data environment are transmitted to the object storage 232according to the data retrieval frequency specified in the connectiongroup.

FIG. 5 illustrates the browsing terminals 302 and the web server 204.The browsing terminals 302 connect to the web server 204 through acomputer network by launching a web browser such as Microsoft InternetExplorer or Netscape Communicator. The applet or applets comprising themodules 252, 254, 256 & 258 are downloaded from the web server 204 tothe browsing terminals 302. Using the downloaded applet(s), the browsingterminals 302 display the views defined in the enterprise server 202representing component instances in solution servers 206. From thebrowsing terminals 302, users can select one or more existing views fordisplay, but cannot update components, views or solutions. If users aregiven access, they can create and edit components, views and solutionsfrom the development clients 210. An example screen display showing howsolutions may be viewed within a web browser is shown in FIG. 16, withthe solution tree shown in the left panel and a populated view of theselected component instance in the right panel.

The router 260 is the data communication gateway between the browsingterminals 302 and the application environment 200. The router 260retrieves view definitions and component definitions from the componenttable 222 in the enterprise server 202. Data and component instancesrequested by the browsing terminals 302 are transmitted from thesolution servers 206 through the router 260 to the browsing terminals302.

A user/developer can use the animation module 252 to pick a data displayfield within a view, and select a “show trend” option to display thechange of data over time for the component member represented by thatdata display field. The trend module 254 then provides a graphicrepresentation of data change over time for the component member.Historical data is retrieved from the time-series historian 234 or theback-end time-series historian.

FIG. 6 is a flowchart illustrating a process of creating a component.When a user or developer selects the menu option “create new component”in the catalog application 242, he/she is then directed to the componentbuilder 244 and prompted to enter a name for the new component in step502. The new component name must be different from existing componentnames. In one embodiment the user/developer is also prompted to enter atext description for the new component. The user/developer is thenprompted to assign a graphic icon to the new component in step 504. Theuser/developer is presented a list of icons or allowed to search foricon files. In the preferred embodiment the user/developer is promptedto assign two icons to a new component, including one small icon and onelarge icon for various display of the component.

The user/developer is then prompted to define members of the component.The user/developer is prompted to define the name of the member in step506, and to select the data type of the member in step 508. The datatype can be a primitive type such as integer, decimal number, Booleanlogical value, text string or date, or an existing component. An examplescreen display illustrating the process of adding an existing componentas a member is shown in FIG. 10. The user/developer continues addingmembers to the component, until he/she indicates at step 510 that allmembers have been added. In the preferred embodiment the user/developermakes this indication by selecting a “save component definition” menuoption. In step 512 the client development client 210 updates thecatalog application 242 to include the name and icon of the viewcomponent. In step 512 the development client 210 also sends the newcomponent definition to the component table 222 in the enterprise server202. In another embodiment, the user or developer starts the process ofcreating a component in the component builder 244.

FIG. 7 is a flowchart illustrating the process of creating a globalcollection. A global collection represents multiple instances of thesame class of data, such as “all orders,” “all customers,” or “allcustomers from the East Regional Database.” A component memberdesignated a collection member is connected to back-end data through“filtering” a global collection, i.e., selecting a subset of a globalcollection. A component member representing multiple instances of thesame type is preferably designated a collection member. A member notdesignated a collection member connects to back-end data through aconnection group, as described above. For example, a component member“customers” of a “sales organization” component may contain a collectionof more than one customer.

Once a global collection is created, a component member can be connectedto back-end data as all or a subset of the global collection. Forexample, once a global collection of “all customers” is created and itsconnection to back-end data defined, a component of “active customers”can be connected to back-end data as a subset of the global collection.Components of “inactive customers” or “preferred customers” can also beconnected as a subset of the global collection. An example screendisplay illustrating the process of connecting a collection component tothe global collection “Customers” is shown in FIG. 14. Relational datarecords with multiple fields may be designated collection members.Members representing programmatic data, i.e, data structures returnedfrom API (Application Programming Interface) calls, can also bedesignated collection members. In this specification,the term“relational data” comprises data structures returned from API calls.

In step 520, a user or developer selects a menu option of “create globalcollection” in the solution builder 248, and enters a name for theglobal collection. The user/developer is then prompted in step 522 toselect a component from a list of existing components to correspond tothe new global collection. This defines the type of data that isassociated with and managed by the global collection. The user/developeris then prompted in step 524 to select a connection group from a list ofexisting connection groups to connect the global connection to back-enddata. For example, an “Oracle” connection group connects to a back-endOracle database, and an “MS-SQL” connection group connects to aMicrosoft SQL database.

In step 526, the user/developer addresses the new global collection.Addressing a global collection provides information needed to acquirethe desired collection data from the back-end environment 100. Theuser/developer enters program commands and configurations to associatethe members of the selected component with back-end data items. In oneembodiment, the user/developer addresses the new global collection byentering a query statement specifying the back-end data items to selectdata from, and maps the specified back-end data items to the members ofthe selected component. In step 528 the solution builder 248 updates theglobal collection list. In the preferred embodiment the updated globalcollection list is displayed at the bottom of the solution tree.

Connecting a component as a subset of an already defined globalcollection typically requires less technical skill than connecting acomponent directly to back-end data. Therefore, the method of creating aglobal collection first, then connecting components as a subset of thecreated global collection eases the technical burden on users anddevelopers. Once the global collection is defined correctly, users ordevelopers who connect components as a subset of the global collectionwill not connect the components to the wrong back-end data sources. Theword “subset,” as used in the specification and the claims, comprises “apart of” and “all of.”

FIG. 8 is a flowchart illustrating a process of creating a solution. Atop-node component must first be identified to build a hierarchicalobject model for display, navigation and data collection. A tree-styledisplay is one form of display of the hierarchical object model. Theuser or developer selects a component as the top-level component in step602 in the solution builder 248. The developer is then prompted in step604 to enter a top-node solution name and description. In step 606 thesolution builder 248 then displays a solution tree with the selectedcomponent at the top node, its members as branches of the tree, andsub-members as sub-branches. In one embodiment only component membersare shown as branches of the tree.

In one embodiment, steps 602 through 606 are preformed using a systemadministration module. When an object model has been created anddisplayed as a solution tree, a user or developer proceeds from step 608within the solution builder 248. In step 608 a user or developer selectsa component represented by a node on the solution tree, and selects the“create solution” option to connect back-end data (i.e., a back end datasource) to an instance of the selected component. The user/developer isprompted in step 610 to select a member of the selected component forconnecting to back-end data. In step 612 the user/developer determineswhether to designate the selected member as a collection data member.

If the selected member is designated a collection data member, then theuser/developer is prompted in step 614 to select a global collectionfrom a list of existing global collections. The user/developer is thenprompted in step 616 to filter the selected global collection, byselecting a subset of said global collection. For example, for acomponent member “active customers,” the user/developer selects a globalcollection “all customers,” and in one embodiment selects a subset ofthe global collection by entering program code “select fromall-customers where customer-status =active.” If the selected member isnot designated a collection data member then the user/developer connectsthe member to back-end data by selecting a connection group from a listof existing connection groups in step 618, and then addressing themember in step 620. The user/developer addresses the selected member instep 620 by specifying the back-end data item that the membercorresponds to.

In step 622, if the user/developer indicates he/she has completedconnecting members to back-end data, then the solution builder 248proceeds to step 624. Otherwise the solution builder 248 returns to step610 to select another member for connection. In step 624 the solutionbuilder 248 transmits the solution definition to the enterprise server202 and solution server 206. The connection specification for eachcomponent member of the solution is stored in the component instancetable 236, and_the name and description of the solution are stored inthe solution table 226.

As indicated above, a developer or user may specify a solution'sconnection to back-end data sources through connection groups, eachcomprising a connection process. Each connection process comprises theprogram command to execute a connector. Connectors can be independentthird party packages or custom programmed for the system. One embodimentuses a connector toolkit developed by the applicant that allowsdevelopers to build connectors in Java, and optionally in C or C++. Adeveloper or user can create different connection groups that use thesame connector. For example, one connection group connects to productiondata for last year; another connection group connects to production datafor the current month, contained in the same back-end data source. Oneconnection group may scan for data at a frequency of every second, whileanother connection group may scan for data, using the same connector, ata frequency of every minute. The system allows a user or developer tospecify the data scanning frequency. A connection group acquiresback-end data using a connection process, which comprises the programcommand for running a connector. An example screen display showing aconnection tab screen of the solution builder 248 is shown in FIG. 13.

The solution builder 248 allows a user or developer to add, modify ordelete a connection process. To add a connection process, theuser/developer selects the option “add a connection process,” and isprompted to enter a name and description for the new connection process.The user/developer is then prompted to enter a program command for theconnection process. A developer typically performs the task of enteringa program command.

The solution builder 248 also allows a user or developer to add, modifyor delete a connection group. To add a connection group, theuser/developer selects the option “add a connection group,” and isprompted to enter a name and description for the new connection group.The user/developer is then prompted to select a connection process froma list of connection processes and a connector type from a list ofconnector types. A connector type is the type of a connector defined inthe connector builder 250. The selected connection process is theconnection process that corresponds to the new connection group. In oneembodiment, the user/developer is then allowed to specify the datascanning frequency of the connection group.

FIG. 9 is a flowchart illustrating a process of creating a view. In step702, a developer or user selects a component from the catalogapplication 242, and selects the menu option “create new view” to createa new view corresponding to the selected component. The user/developeris then directed to the view builder 246 and prompted to enter a namefor that view, in step 704. In one embodiment the user/developer is alsoprompted to enter a description for that view in step 704.

In step 706, the user/developer is prompted to select a graphic tool.Graphic representations are created using graphic tools, which comprisetools for drawing tables, charts, lines, animations, etc. The viewbuilder 246 has a set of drawing tools for presenting titles, charts,tables, backgrounds graphics, and other graphical elements. The viewbuilder 246 also allows a developer or user to create and editanimations. Animation characteristics, such as fill color and size,change based on fluctuations in back-end data. Animations containreferences to component members that are linked through a solution tocollect data from back-end data sources. The view builder 246 alsoallows the creation and editing of views as web hyperlinks to URLs(Uniform Resource Locators). In one embodiment, the user or developerstarts the process of creating a view from the view builder 246.

If the user/developer selects a view-in-view tool, i.e. a tool forinserting a view inside a view, then step 708 proceeds to step 714. Ifthe selected tool is not a tool for inserting a view inside a view, thenstep 708 proceeds to step 710. A view-in-view tool allows auser/developer to insert, within a view representing a component, asub-view representing a component member of that component at a locationdetermined by the user/developer. An example view builder screen displayillustrating the process of inserting one view into another view isshown in FIG. 15.

In step 710 the user/developer creates graphic representation using theselected tool. The graphic representation may comprise an animation. Thegraphic representation also may comprise program commands forassociating data values with the graphic effects. For example, auser/developer can use the selected graphic tool to represent a “pumptemperature” field as a blue rectangle, and enter a program command tofill the rectangle with red color or flashing red color when temperatureexceed five hundred degrees. The user/developer then is directed to step722.

If the user/developer selects a view-in-view tool, then in step 714 theuser/developer is prompted to select a member of the selected component.Since a view representing the selected member is to be inserted to thenewly created view representing the selected component, the selectedmember is a component itself. In one embodiment the user/developer isprompted to select from a list of component members of the selectedcomponent. The user/developer is prompted to select a view from theexisting views of the member component, in step 716. The user/developeruses the view-in-view tool to place the selected member view inside thenewly created component view.

The view builder 246 then determines in step 718 if the selected memberis designated as a collection member. If the selected member is acollection member, then the user/developer is prompted in step 720 todetermine the number of views to be displayed for the collection member.In one embodiment the user/developer is prompted to enter the number ofrows and columns to be displayed for the collection member.

In step 722, the user/developer can opt to return to step 706 tocontinue preparation of the graphic representation of the selectedcomponent. If the user/developer indicates that the view is complete,the view builder 246 transmits the created view definition to enterpriseserver 202 to be stored in the component table 222 (step 724).

In one embodiment, a default view is defined for each component that hasone or more views associated with the component. When a component has nocorresponding views, the first view created for that component isdefined as the default view. When a component has one or morecorresponding views, a user/developer can define the default view byselecting the component in the catalog application 242 and entering a“update component—update default view” option. This embodiment can beachieved by having a “default view? Yes or No” logical field within theview definition, or by having a “default view” field within thecomponent definition containing the name of the default view. When aview representing a component having a component member is displayed,the sub-view representing the component member is also displayed. When auser/developer selects the sub-view, preferably by highlighting ordouble-clicking with a mouse, the default view representing thecomponent member is displayed. For example, within a view representing aplant operation is displayed a view representing a motor. When the viewrepresenting the motor is selected, the default view representing themotor is displayed, which is typically a detailed view of the motor. Auser/developer is thus allowed to “drill down” to further details. Auser/developer can also select another view of the component member,preferably by right-clicking on the sub-view to bring up a list of viewscorresponding to the component member and selecting one of the viewsfrom the list.

At run time, data is retrieved through connections defined in asolution, and displayed using a view associated with the component thatis associated with the solution.

The provisional application on which this application is based,including its attached “Indx XHQ User's Guide,” is hereby incorporatedinto the specification.

Although the foregoing has been a description and illustration ofspecific embodiments of the invention, various modifications and changescan be made thereto by persons skilled in the art without departing fromthe scope and spirit of the invention as defined by the followingclaims.

1. A method of generating a computer model for the collection anddisplay of data, the method comprising: generating a first reusablesoftware component that collects data from a first type of data source;generating a first view that specifies how data collected by the firstcomponent is to be displayed; creating multiple instances of the firstcomponent, each such instance corresponding to a different respectivedata source of the first type and using the first view to display datacollected therefrom; and connecting each instance of the first componentto its respective data source such that at least some of the multipleinstances are configured to retrieve data from their respective datasources in a different manner than others of the multiple instances. 2.The method of claim 1, wherein the method comprises separatelyspecifying a data retrieval frequency for each instance of the at leastsome multiple instances of the first component.
 3. The method of claim1, wherein connecting each instance of the first component to itsrespective data source comprises specifying program code forestablishing a connection between a data source and an instance of thefirst component.
 4. The method of claim 1, further comprising generatinga second reusable software component that collects data from a secondtype of data source, said second component including the first componentas a member.
 5. The method of claim 4, further comprising generating asecond view that specifies how data collected by the second component isto be displayed, said second view including the first view such thatwhen a user accesses the second view to view data collected by aninstance of the second component, the second view is displayed withinthe first view.
 6. The method of claim 4, wherein the second componentrepresents a plant, and the first component represents an item ofmachinery within the plant.
 7. The method of claim 4, further comprisingdisplaying a navigation interface in which the first component isrepresented as a child of the second component within a hierarchicalnode structure, wherein nodes of the hierarchical node structure areselectable to view data collected by corresponding components.
 8. Acomputer model generated according to the method of claim 1 representedwithin computer storage.
 9. A model development system capable ofperforming the method of claim 1 to generate a model.
 10. A developmentsystem for developing computer models for the collection and display ofdata, the development system comprising: a component builder thatprovides functionality for generating reusable components for collectingdata from back-end data sources, including back-end data sourcesassociated with business elements, whereby a user may create a reusablecomponent that represents a particular type of business element; a viewbuilder that provides functionality for generating views that correspondto specific components generated by the component builder, whereby auser can generate one or more views that specify how data collected by acorresponding component is to be displayed; a catalog that containscomponents generated with the component builder; and a module thatprovides functionality for selecting components from the catalog,creating multiple instances of a selected component to representmultiple elements of a common type, and connecting an instance to arespective source of back-end data to allow that instance to collectdata.
 11. The development system of claim 10, wherein the componentbuilder provides functionality for generating a component that includesone or more other components generated by the component builder, wherebysub-units of an element are modeled as sub-components of the componentrepresenting that element.
 12. The development system of claim 10,wherein the module enables a user to specify a frequency with which datais to be collected from a selected data source.
 13. The developmentsystem of claim 10, wherein the module enables a user to separatelyspecify, for each instance of a component, a frequency with which datais to be collected from a corresponding data source.
 14. The developmentsystem of claim 10, wherein the component builder provides functionalityfor generating components that collect point data, relational data, andtime series data.
 15. The development system of claim 10, wherein thecomponent builder provides functionality for generating components thatcollect data structures via application program interface (API) calls.16. The development system of claim 10 wherein the view builder furtherprovides functionality for inserting a view corresponding to a firstcomponent within a view corresponding to a second component.